home *** CD-ROM | disk | FTP | other *** search
/ Freelog 115 / FreelogNo115-MaiJuin2013.iso / Internet / Filezilla Server / FileZilla_Server-0_9_41.exe / source / interface / UsersDlgSpeedLimit.cpp < prev    next >
C/C++ Source or Header  |  2011-11-06  |  16KB  |  487 lines
  1. // FileZilla Server - a Windows ftp server
  2.  
  3. // Copyright (C) 2002-2004 - Tim Kosse <tim.kosse@gmx.de>
  4.  
  5. // This program is free software; you can redistribute it and/or
  6. // modify it under the terms of the GNU General Public License
  7. // as published by the Free Software Foundation; either version 2
  8. // of the License, or (at your option) any later version.
  9.  
  10. // This program is distributed in the hope that it will be useful,
  11. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. // GNU General Public License for more details.
  14.  
  15. // You should have received a copy of the GNU General Public License
  16. // along with this program; if not, write to the Free Software
  17. // Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18.  
  19. // UsersDlgSpeedLimit.cpp: Implementierungsdatei
  20. //
  21.  
  22. #include "stdafx.h"
  23. #include "filezilla server.h"
  24. #include "UsersDlgSpeedLimit.h"
  25. #include "SpeedLimitRuleDlg.h"
  26.  
  27. /////////////////////////////////////////////////////////////////////////////
  28. // CUsersDlgSpeedLimit dialog
  29.  
  30.  
  31. CUsersDlgSpeedLimit::CUsersDlgSpeedLimit(CUsersDlg* pOwner) 
  32.     : CSAPrefsSubDlg(IDD)
  33. {
  34.     m_pOwner = pOwner;
  35.     
  36.     //{{AFX_DATA_INIT(CUsersDlgSpeedLimit)
  37.     m_DownloadSpeedLimitType = -1;
  38.     m_UploadSpeedLimitType = -1;
  39.     m_DownloadValue = 10;
  40.     m_UploadValue = 10;
  41.     //}}AFX_DATA_INIT
  42. }
  43.  
  44. CUsersDlgSpeedLimit::~CUsersDlgSpeedLimit()
  45. {
  46. }
  47.  
  48. void CUsersDlgSpeedLimit::DoDataExchange(CDataExchange* pDX)
  49. {
  50.     CSAPrefsSubDlg::DoDataExchange(pDX);
  51.     //{{AFX_DATA_MAP(CUsersDlgSpeedLimit)
  52.     DDX_Control(pDX, IDC_SPEEDLIMIT_DOWNLOAD_UP, m_DownloadUpCtrl);
  53.     DDX_Control(pDX, IDC_SPEEDLIMIT_DOWNLOAD_RULES_LIST, m_DownloadRulesListCtrl);
  54.     DDX_Control(pDX, IDC_SPEEDLIMIT_DOWNLOAD_REMOVE, m_DownloadRemoveCtrl);
  55.     DDX_Control(pDX, IDC_SPEEDLIMIT_DOWNLOAD_DOWN, m_DownloadDownCtrl);
  56.     DDX_Control(pDX, IDC_SPEEDLIMIT_DOWNLOAD_ADD, m_DownloadAddCtrl);
  57.     DDX_Control(pDX, IDC_SPEEDLIMIT_UPLOAD_UP, m_UploadUpCtrl);
  58.     DDX_Control(pDX, IDC_SPEEDLIMIT_UPLOAD_RULES_LIST, m_UploadRulesListCtrl);
  59.     DDX_Control(pDX, IDC_SPEEDLIMIT_UPLOAD_REMOVE, m_UploadRemoveCtrl);
  60.     DDX_Control(pDX, IDC_SPEEDLIMIT_UPLOAD_DOWN, m_UploadDownCtrl);
  61.     DDX_Control(pDX, IDC_SPEEDLIMIT_UPLOAD_ADD, m_UploadAddCtrl);
  62.     DDX_Control(pDX, IDC_SPEEDLIMIT_UPLOAD_VALUE, m_UploadValueCtrl);
  63.     DDX_Control(pDX, IDC_SPEEDLIMIT_DOWNLOAD_VALUE, m_DownloadValueCtrl);
  64.     DDX_Radio(pDX, IDC_SPEEDLIMIT_DOWNLOAD1, m_DownloadSpeedLimitType);
  65.     DDX_Radio(pDX, IDC_SPEEDLIMIT_UPLOAD1, m_UploadSpeedLimitType);
  66.     DDX_Text(pDX, IDC_SPEEDLIMIT_DOWNLOAD_VALUE, m_DownloadValue);
  67.     DDV_MinMaxInt(pDX, m_DownloadValue, 1, 1000000000);
  68.     DDX_Text(pDX, IDC_SPEEDLIMIT_UPLOAD_VALUE, m_UploadValue);
  69.     DDV_MinMaxInt(pDX, m_UploadValue, 1, 1000000000);
  70.     //}}AFX_DATA_MAP
  71. }
  72.  
  73.  
  74. BEGIN_MESSAGE_MAP(CUsersDlgSpeedLimit, CSAPrefsSubDlg)
  75.     //{{AFX_MSG_MAP(CUsersDlgSpeedLimit)
  76.     ON_BN_CLICKED(IDC_SPEEDLIMIT_DOWNLOAD1, OnRadio)
  77.     ON_BN_CLICKED(IDC_SPEEDLIMIT_DOWNLOAD_ADD, OnSpeedlimitDownloadAdd)
  78.     ON_BN_CLICKED(IDC_SPEEDLIMIT_DOWNLOAD_REMOVE, OnSpeedlimitDownloadRemove)
  79.     ON_BN_CLICKED(IDC_SPEEDLIMIT_DOWNLOAD_UP, OnSpeedlimitDownloadUp)
  80.     ON_BN_CLICKED(IDC_SPEEDLIMIT_DOWNLOAD_DOWN, OnSpeedlimitDownloadDown)
  81.     ON_LBN_DBLCLK(IDC_SPEEDLIMIT_DOWNLOAD_RULES_LIST, OnDblclkSpeedlimitDownloadRulesList)
  82.     ON_BN_CLICKED(IDC_SPEEDLIMIT_UPLOAD_ADD, OnSpeedlimitUploadAdd)
  83.     ON_BN_CLICKED(IDC_SPEEDLIMIT_UPLOAD_REMOVE, OnSpeedlimitUploadRemove)
  84.     ON_BN_CLICKED(IDC_SPEEDLIMIT_UPLOAD_UP, OnSpeedlimitUploadUp)
  85.     ON_BN_CLICKED(IDC_SPEEDLIMIT_UPLOAD_DOWN, OnSpeedlimitUploadDown)
  86.     ON_BN_CLICKED(IDC_SPEEDLIMIT_UPLOAD1, OnRadio)
  87.     ON_BN_CLICKED(IDC_SPEEDLIMIT_DOWNLOAD2, OnRadio)
  88.     ON_BN_CLICKED(IDC_SPEEDLIMIT_UPLOAD2, OnRadio)
  89.     ON_BN_CLICKED(IDC_SPEEDLIMIT_DOWNLOAD3, OnRadio)
  90.     ON_BN_CLICKED(IDC_SPEEDLIMIT_UPLOAD3, OnRadio)
  91.     ON_BN_CLICKED(IDC_SPEEDLIMIT_DOWNLOAD4, OnRadio)
  92.     ON_BN_CLICKED(IDC_SPEEDLIMIT_UPLOAD4, OnRadio)
  93.     ON_LBN_DBLCLK(IDC_SPEEDLIMIT_UPLOAD_RULES_LIST, OnDblclkSpeedlimitUploadRulesList)
  94.     //}}AFX_MSG_MAP
  95. END_MESSAGE_MAP()
  96.  
  97. /////////////////////////////////////////////////////////////////////////////
  98. // CUsersDlgSpeedLimit message handlers
  99.  
  100. void CUsersDlgSpeedLimit::SetCtrlState()
  101. {
  102.     UpdateData(TRUE);
  103.  
  104.     ShowSpeedLimit(m_DownloadRulesListCtrl, m_DownloadSpeedLimits);
  105.     ShowSpeedLimit(m_UploadRulesListCtrl, m_UploadSpeedLimits);
  106.  
  107.     if (!m_pOwner->GetCurrentUser())
  108.     {
  109.         m_DownloadValueCtrl.EnableWindow(FALSE);
  110.         m_DownloadUpCtrl.EnableWindow(FALSE);
  111.         m_DownloadRulesListCtrl.EnableWindow(FALSE);
  112.         m_DownloadRemoveCtrl.EnableWindow(FALSE);
  113.         m_DownloadDownCtrl.EnableWindow(FALSE);
  114.         m_DownloadAddCtrl.EnableWindow(FALSE);
  115.         
  116.         m_UploadValueCtrl.EnableWindow(FALSE);
  117.         m_UploadUpCtrl.EnableWindow(FALSE);
  118.         m_UploadRulesListCtrl.EnableWindow(FALSE);
  119.         m_UploadRemoveCtrl.EnableWindow(FALSE);
  120.         m_UploadDownCtrl.EnableWindow(FALSE);
  121.         m_UploadAddCtrl.EnableWindow(FALSE);
  122.  
  123.         GetDlgItem(IDC_SPEEDLIMIT_DOWNLOAD1)->EnableWindow(FALSE);
  124.         GetDlgItem(IDC_SPEEDLIMIT_DOWNLOAD2)->EnableWindow(FALSE);
  125.         GetDlgItem(IDC_SPEEDLIMIT_DOWNLOAD3)->EnableWindow(FALSE);
  126.         GetDlgItem(IDC_SPEEDLIMIT_DOWNLOAD4)->EnableWindow(FALSE);
  127.         GetDlgItem(IDC_SPEEDLIMIT_UPLOAD1)->EnableWindow(FALSE);
  128.         GetDlgItem(IDC_SPEEDLIMIT_UPLOAD2)->EnableWindow(FALSE);
  129.         GetDlgItem(IDC_SPEEDLIMIT_UPLOAD3)->EnableWindow(FALSE);
  130.         GetDlgItem(IDC_SPEEDLIMIT_UPLOAD4)->EnableWindow(FALSE);
  131.  
  132.         ((CButton *)GetDlgItem(IDC_USERS_SPEEDLIMIT_SERVERBYPASS_DOWNLOAD))->EnableWindow(FALSE);
  133.         ((CButton *)GetDlgItem(IDC_USERS_SPEEDLIMIT_SERVERBYPASS_UPLOAD))->EnableWindow(FALSE);
  134.     }
  135.     else
  136.     {
  137.         m_DownloadValueCtrl.EnableWindow(m_DownloadSpeedLimitType == 2);
  138.         m_DownloadUpCtrl.EnableWindow(m_DownloadSpeedLimitType == 3);
  139.         m_DownloadRulesListCtrl.EnableWindow(m_DownloadSpeedLimitType == 3);
  140.         m_DownloadRemoveCtrl.EnableWindow(m_DownloadSpeedLimitType == 3);
  141.         m_DownloadDownCtrl.EnableWindow(m_DownloadSpeedLimitType == 3);
  142.         m_DownloadAddCtrl.EnableWindow(m_DownloadSpeedLimitType == 3);
  143.         
  144.         m_UploadValueCtrl.EnableWindow(m_UploadSpeedLimitType == 2);
  145.         m_UploadUpCtrl.EnableWindow(m_UploadSpeedLimitType == 3);
  146.         m_UploadRulesListCtrl.EnableWindow(m_UploadSpeedLimitType == 3);
  147.         m_UploadRemoveCtrl.EnableWindow(m_UploadSpeedLimitType == 3);
  148.         m_UploadDownCtrl.EnableWindow(m_UploadSpeedLimitType == 3);
  149.         m_UploadAddCtrl.EnableWindow(m_UploadSpeedLimitType == 3);
  150.  
  151.         GetDlgItem(IDC_SPEEDLIMIT_DOWNLOAD1)->EnableWindow(TRUE);
  152.         GetDlgItem(IDC_SPEEDLIMIT_DOWNLOAD2)->EnableWindow(TRUE);
  153.         GetDlgItem(IDC_SPEEDLIMIT_DOWNLOAD3)->EnableWindow(TRUE);
  154.         GetDlgItem(IDC_SPEEDLIMIT_DOWNLOAD4)->EnableWindow(TRUE);
  155.         GetDlgItem(IDC_SPEEDLIMIT_UPLOAD1)->EnableWindow(TRUE);
  156.         GetDlgItem(IDC_SPEEDLIMIT_UPLOAD2)->EnableWindow(TRUE);
  157.         GetDlgItem(IDC_SPEEDLIMIT_UPLOAD3)->EnableWindow(TRUE);
  158.         GetDlgItem(IDC_SPEEDLIMIT_UPLOAD4)->EnableWindow(TRUE);
  159.  
  160.         ((CButton *)GetDlgItem(IDC_USERS_SPEEDLIMIT_SERVERBYPASS_DOWNLOAD))->EnableWindow(TRUE);
  161.         ((CButton *)GetDlgItem(IDC_USERS_SPEEDLIMIT_SERVERBYPASS_UPLOAD))->EnableWindow(TRUE);
  162.     }
  163. }
  164.  
  165. BOOL CUsersDlgSpeedLimit::OnInitDialog() 
  166. {
  167.     CSAPrefsSubDlg::OnInitDialog();
  168.     
  169.     SetCtrlState();
  170.  
  171.     ShowSpeedLimit( m_DownloadRulesListCtrl, m_DownloadSpeedLimits);
  172.     ShowSpeedLimit( m_UploadRulesListCtrl, m_UploadSpeedLimits);
  173.  
  174.     return TRUE;  // return TRUE unless you set the focus to a control
  175.                   // EXCEPTION: OCX Property Pages should return FALSE
  176. }
  177.  
  178. void CUsersDlgSpeedLimit::OnRadio() 
  179. {
  180.     SetCtrlState();
  181. }
  182.  
  183. void CUsersDlgSpeedLimit::OnSpeedlimitDownloadAdd() 
  184. {
  185.     CSpeedLimitRuleDlg dlg;
  186.  
  187.     if ( dlg.DoModal() == IDOK)
  188.     {
  189.         m_DownloadSpeedLimits.push_back(dlg.GetSpeedLimit());
  190.  
  191.         ShowSpeedLimit( m_DownloadRulesListCtrl, m_DownloadSpeedLimits);
  192.     }
  193. }
  194.  
  195. void CUsersDlgSpeedLimit::ShowSpeedLimit(CListBox &listBox, SPEEDLIMITSLIST &list)
  196. {
  197.     listBox.ResetContent();
  198.  
  199.     for (unsigned int i = 0; i < list.size(); i++)
  200.     {
  201.         CString str;
  202.         
  203.         str.Format(_T( "%dkB/s"), list[i].m_Speed);
  204.  
  205.         CString help;
  206.         
  207.         if (list[i].m_DateCheck)
  208.         {
  209.             CTime t(list[i].m_Date.y, list[i].m_Date.m, list[i].m_Date.d, 0, 0, 0);
  210.             help += t.Format(_T("%x"));
  211.         }
  212.         
  213.         if (list[i].m_FromCheck)
  214.         {
  215.             if (help.GetLength() > 0)
  216.                 help += _T( "; ");
  217.             
  218.             CTime t(2003, 1, 1, list[i].m_FromTime.h, list[i].m_FromTime.m, list[i].m_FromTime.s);
  219.             help += _T("F:") + t.Format( _T("%X"));
  220.         }
  221.         
  222.         if (list[i].m_ToCheck)
  223.         {
  224.             if (help.GetLength() > 0)
  225.                 help += _T( "; ");
  226.             
  227.             CTime t(2003, 1, 1, list[i].m_ToTime.h, list[i].m_ToTime.m, list[i].m_ToTime.s);
  228.             help += _T("T:") + t.Format( _T("%X"));
  229.         }
  230.         
  231.         for (int j = 0; j < 7; j++)
  232.             if (!(list[i].m_Day & (1<<j)))
  233.             {
  234.                 if (help.GetLength() > 0)
  235.                     help += _T( "; ");
  236.                 
  237.                 bool was = false;
  238.                 for ( int k = 0; k < 7; k++)
  239.                 {
  240.                     if ((list[i].m_Day & (1<<k)))
  241.                     {
  242.                         if (was)
  243.                             help += _T(", ");
  244.                         
  245.                         was = true;
  246.                         
  247.                         CTime time(2001, 1, k + 1, 0, 0, 0);
  248.                         
  249.                         help += time.Format(_T("%a"));
  250.                     }
  251.                 }
  252.                 
  253.                 break;
  254.             }
  255.         
  256.         str += _T(" [") + help + _T("]");
  257.         
  258.         listBox.AddString(str);
  259.     }
  260. }
  261.  
  262. void CUsersDlgSpeedLimit::OnSpeedlimitDownloadRemove() 
  263. {
  264.     int curSel = m_DownloadRulesListCtrl.GetCurSel();
  265.  
  266.     if ( ( curSel >= 0) && ( curSel < (int)m_DownloadSpeedLimits.size()))
  267.     {
  268.         for (SPEEDLIMITSLIST::iterator iter=m_DownloadSpeedLimits.begin(); iter!=m_DownloadSpeedLimits.end(); iter++)
  269.         {
  270.             if (!curSel)
  271.             {
  272.                 m_DownloadSpeedLimits.erase(iter);
  273.                 break;
  274.             }
  275.             curSel--;
  276.         }
  277.  
  278.         ShowSpeedLimit( m_DownloadRulesListCtrl, m_DownloadSpeedLimits);
  279.     }
  280. }
  281.  
  282. void CUsersDlgSpeedLimit::OnSpeedlimitDownloadUp() 
  283. {
  284.     int curSel = m_DownloadRulesListCtrl.GetCurSel();
  285.  
  286.     if ( ( curSel >= 1) && ( curSel < (int)m_DownloadSpeedLimits.size()))
  287.     {
  288.         CSpeedLimit sl = m_DownloadSpeedLimits[curSel];
  289.         m_DownloadSpeedLimits[curSel] = m_DownloadSpeedLimits[curSel - 1];
  290.         m_DownloadSpeedLimits[curSel - 1] = sl;
  291.  
  292.         ShowSpeedLimit( m_DownloadRulesListCtrl, m_DownloadSpeedLimits);
  293.  
  294.         m_DownloadRulesListCtrl.SetCurSel( curSel - 1);
  295.     }
  296. }
  297.  
  298. void CUsersDlgSpeedLimit::OnSpeedlimitDownloadDown() 
  299. {
  300.     int curSel = m_DownloadRulesListCtrl.GetCurSel();
  301.  
  302.     if ( ( curSel >= 0) && ( curSel < (int)m_DownloadSpeedLimits.size() - 1))
  303.     {
  304.         CSpeedLimit sl = m_DownloadSpeedLimits[curSel];
  305.         m_DownloadSpeedLimits[curSel] = m_DownloadSpeedLimits[curSel + 1];
  306.         m_DownloadSpeedLimits[curSel + 1] = sl;
  307.  
  308.         ShowSpeedLimit( m_DownloadRulesListCtrl, m_DownloadSpeedLimits);
  309.  
  310.         m_DownloadRulesListCtrl.SetCurSel( curSel + 1);
  311.     }
  312. }
  313.  
  314. void CUsersDlgSpeedLimit::OnDblclkSpeedlimitDownloadRulesList() 
  315. {
  316.     int curSel = m_DownloadRulesListCtrl.GetCurSel();
  317.  
  318.     if ( ( curSel >= 0) && ( curSel < (int)m_DownloadSpeedLimits.size()))
  319.     {
  320.         CSpeedLimitRuleDlg dlg;
  321.  
  322.         dlg.FillFromSpeedLimit(m_DownloadSpeedLimits[curSel]);
  323.  
  324.         if ( dlg.DoModal() == IDOK)
  325.         {
  326.             m_DownloadSpeedLimits[curSel] = dlg.GetSpeedLimit();
  327.  
  328.             ShowSpeedLimit(m_DownloadRulesListCtrl, m_DownloadSpeedLimits);
  329.             m_DownloadRulesListCtrl.SetCurSel(curSel);
  330.         }
  331.     }
  332. }
  333.  
  334. void CUsersDlgSpeedLimit::OnSpeedlimitUploadRemove() 
  335. {
  336.     int curSel = m_UploadRulesListCtrl.GetCurSel();
  337.  
  338.     if ( ( curSel >= 0) && ( curSel < (int)m_UploadSpeedLimits.size()))
  339.     {
  340.         for (SPEEDLIMITSLIST::iterator iter=m_UploadSpeedLimits.begin(); iter!=m_UploadSpeedLimits.end(); iter++)
  341.         {
  342.             if (!curSel)
  343.             {
  344.                 m_UploadSpeedLimits.erase(iter);
  345.                 break;
  346.             }
  347.             curSel--;
  348.         }
  349.  
  350.         ShowSpeedLimit( m_UploadRulesListCtrl, m_UploadSpeedLimits);
  351.     }
  352. }
  353.  
  354. void CUsersDlgSpeedLimit::OnSpeedlimitUploadUp() 
  355. {
  356.     int curSel = m_UploadRulesListCtrl.GetCurSel();
  357.  
  358.     if ( ( curSel >= 1) && ( curSel < (int)m_UploadSpeedLimits.size()))
  359.     {
  360.         CSpeedLimit sl = m_UploadSpeedLimits[curSel];
  361.         m_UploadSpeedLimits[curSel] = m_UploadSpeedLimits[curSel - 1];
  362.         m_UploadSpeedLimits[curSel - 1] = sl;
  363.  
  364.         ShowSpeedLimit( m_UploadRulesListCtrl, m_UploadSpeedLimits);
  365.  
  366.         m_UploadRulesListCtrl.SetCurSel( curSel - 1);
  367.     }
  368. }
  369.  
  370. void CUsersDlgSpeedLimit::OnSpeedlimitUploadDown() 
  371. {
  372.     int curSel = m_UploadRulesListCtrl.GetCurSel();
  373.  
  374.     if ( ( curSel >= 0) && ( curSel < (int)m_UploadSpeedLimits.size() - 1))
  375.     {
  376.         CSpeedLimit sl = m_UploadSpeedLimits[curSel];
  377.         m_UploadSpeedLimits[curSel] = m_UploadSpeedLimits[curSel + 1];
  378.         m_UploadSpeedLimits[curSel + 1] = sl;
  379.  
  380.         ShowSpeedLimit( m_UploadRulesListCtrl, m_UploadSpeedLimits);
  381.  
  382.         m_UploadRulesListCtrl.SetCurSel( curSel + 1);
  383.     }
  384. }
  385.  
  386. void CUsersDlgSpeedLimit::OnSpeedlimitUploadAdd() 
  387. {
  388.     CSpeedLimitRuleDlg dlg;
  389.  
  390.     if ( dlg.DoModal() == IDOK)
  391.     {
  392.         m_UploadSpeedLimits.push_back( dlg.GetSpeedLimit());
  393.  
  394.         ShowSpeedLimit( m_UploadRulesListCtrl, m_UploadSpeedLimits);
  395.     }
  396. }
  397.  
  398. void CUsersDlgSpeedLimit::OnDblclkSpeedlimitUploadRulesList() 
  399. {
  400.     int curSel = m_UploadRulesListCtrl.GetCurSel();
  401.  
  402.     if ( ( curSel >= 0) && ( curSel < (int)m_UploadSpeedLimits.size()))
  403.     {
  404.         CSpeedLimitRuleDlg dlg;
  405.  
  406.         dlg.FillFromSpeedLimit( m_UploadSpeedLimits[curSel]);
  407.  
  408.         if (dlg.DoModal() == IDOK)
  409.         {
  410.             m_UploadSpeedLimits[curSel] = dlg.GetSpeedLimit();
  411.  
  412.             ShowSpeedLimit( m_UploadRulesListCtrl, m_UploadSpeedLimits);
  413.             m_UploadRulesListCtrl.SetCurSel( curSel);
  414.         }
  415.     }
  416. }
  417.  
  418. BOOL CUsersDlgSpeedLimit::DisplayUser(const t_user *pUser)
  419. {
  420.     if (!pUser)
  421.     {
  422.         m_DownloadValue = 10;
  423.         m_UploadValue = 10;
  424.         m_DownloadSpeedLimitType = -1;
  425.         m_UploadSpeedLimitType = -1;
  426.  
  427.         m_DownloadSpeedLimits.clear();
  428.         m_UploadSpeedLimits.clear();
  429.  
  430.         ((CButton *)GetDlgItem(IDC_USERS_SPEEDLIMIT_SERVERBYPASS_DOWNLOAD))->SetCheck(0);
  431.         ((CButton *)GetDlgItem(IDC_USERS_SPEEDLIMIT_SERVERBYPASS_UPLOAD))->SetCheck(0);
  432.     }
  433.     else
  434.     {
  435.         m_DownloadValue = pUser->nSpeedLimit[download];
  436.         m_UploadValue = pUser->nSpeedLimit[upload];
  437.         m_DownloadSpeedLimitType = pUser->nSpeedLimitType[download];
  438.         m_UploadSpeedLimitType = pUser->nSpeedLimitType[upload];
  439.  
  440.         m_DownloadSpeedLimits = pUser->SpeedLimits[download];
  441.         m_UploadSpeedLimits = pUser->SpeedLimits[upload];
  442.  
  443.         if (pUser->group == _T(""))
  444.         {
  445.             ((CButton *)GetDlgItem(IDC_USERS_SPEEDLIMIT_SERVERBYPASS_DOWNLOAD))->SetButtonStyle(BS_AUTOCHECKBOX);
  446.             ((CButton *)GetDlgItem(IDC_USERS_SPEEDLIMIT_SERVERBYPASS_UPLOAD))->SetButtonStyle(BS_AUTOCHECKBOX);
  447.         }
  448.         else
  449.         {
  450.             ((CButton *)GetDlgItem(IDC_USERS_SPEEDLIMIT_SERVERBYPASS_DOWNLOAD))->SetButtonStyle(BS_AUTO3STATE);
  451.             ((CButton *)GetDlgItem(IDC_USERS_SPEEDLIMIT_SERVERBYPASS_UPLOAD))->SetButtonStyle(BS_AUTO3STATE);
  452.         }
  453.  
  454.         ((CButton *)GetDlgItem(IDC_USERS_SPEEDLIMIT_SERVERBYPASS_DOWNLOAD))->SetCheck(pUser->nBypassServerSpeedLimit[download] % 3);
  455.         ((CButton *)GetDlgItem(IDC_USERS_SPEEDLIMIT_SERVERBYPASS_UPLOAD))->SetCheck(pUser->nBypassServerSpeedLimit[upload] % 3);
  456.     }
  457.  
  458.     UpdateData(FALSE);
  459.  
  460.     return TRUE;
  461. }
  462.  
  463. BOOL CUsersDlgSpeedLimit::SaveUser(t_user *pUser)
  464. {
  465.     UpdateData(TRUE);
  466.     if (m_DownloadValue > 65535)
  467.         m_DownloadValue = 65535;
  468.     if (m_UploadValue > 65535)
  469.         m_UploadValue = 65535;
  470.     pUser->nSpeedLimit[download] = m_DownloadValue;
  471.     pUser->nSpeedLimit[upload] = m_UploadValue;
  472.     pUser->nSpeedLimitType[download] = m_DownloadSpeedLimitType;
  473.     pUser->nSpeedLimitType[upload] = m_UploadSpeedLimitType;
  474.  
  475.     pUser->SpeedLimits[download] = m_DownloadSpeedLimits;
  476.     pUser->SpeedLimits[upload] = m_UploadSpeedLimits;
  477.  
  478.     pUser->nBypassServerSpeedLimit[download] = ((CButton *)GetDlgItem(IDC_USERS_SPEEDLIMIT_SERVERBYPASS_DOWNLOAD))->GetCheck();
  479.     pUser->nBypassServerSpeedLimit[upload] = ((CButton *)GetDlgItem(IDC_USERS_SPEEDLIMIT_SERVERBYPASS_UPLOAD))->GetCheck();
  480.  
  481.     return TRUE;
  482. }
  483.  
  484. CString CUsersDlgSpeedLimit::Validate()
  485. {
  486.     return _T("");
  487. }